Be more explicit about temporary workspaces

diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs
index ff4a6219df748269fc5a9f9416b2ff8d8555f611..292a662ceabe6ab415ab3bdb1b2d9a4b3614be5a 100644 (file)
--- a/src/cargo/core/registry.rs
+++ b/src/cargo/core/registry.rs
@@ -153,8 +153,7 @@ impl<'cfg> PackageRegistry<'cfg> {
         self.add_source(source, Kind::Locked);
     }
 
-    fn add_source(&mut self, source: Box<Source + 'cfg>,
-                  kind: Kind) {
+    fn add_source(&mut self, source: Box<Source + 'cfg>, kind: Kind) {
         let id = source.source_id().clone();
         self.sources.insert(source);
         self.source_ids.insert(id.clone(), (id, kind));

diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
index c396755e870695ae4c791694006e3cffe5d04e75..870733f96d9992d0734aca4a6ca2398a96d3ad39 100644 (file)
--- a/src/cargo/core/workspace.rs
+++ b/src/cargo/core/workspace.rs
@@ -40,6 +40,10 @@ pub struct Workspace<'cfg> {
     // paths. The packages themselves can be looked up through the `packages`
     // set above.
     members: Vec<PathBuf>,
+
+    // True, if this is a temporary workspace created for the purposes of
+    // cargo install or cargo package.
+    is_ephemeral: bool,
 }
 
 // Separate structure for tracking loaded packages (to avoid loading anything
@@ -94,6 +98,7 @@ impl<'cfg> Workspace<'cfg> {
             root_manifest: None,
             target_dir: target_dir,
             members: Vec::new(),
+            is_ephemeral: false,
         };
         ws.root_manifest = ws.find_root(manifest_path)?;
         ws.find_members()?;
@@ -110,8 +115,8 @@ impl<'cfg> Workspace<'cfg> {
     ///
     /// This is currently only used in niche situations like `cargo install` or
     /// `cargo package`.
-    pub fn one(package: Package, config: &'cfg Config, target_dir: Option<Filesystem>)
-               -> CargoResult<Workspace<'cfg>> {
+    pub fn ephemeral(package: Package, config: &'cfg Config, target_dir: Option<Filesystem>)
+                     -> CargoResult<Workspace<'cfg>> {
         let mut ws = Workspace {
             config: config,
             current_manifest: package.manifest_path().to_path_buf(),
@@ -122,6 +127,7 @@ impl<'cfg> Workspace<'cfg> {
             root_manifest: None,
             target_dir: None,
             members: Vec::new(),
+            is_ephemeral: true,
         };
         {
             let key = ws.current_manifest.parent().unwrap();
@@ -209,6 +215,10 @@ impl<'cfg> Workspace<'cfg> {
         }
     }
 
+    pub fn is_ephemeral(&self) -> bool {
+        self.is_ephemeral
+    }
+
     /// Finds the root of a workspace for the crate whose manifest is located
     /// at `manifest_path`.
     ///

diff --git a/src/cargo/ops/cargo_install.rs b/src/cargo/ops/cargo_install.rs
index f6715992fd3f2128a94c13e0e45608c18632179c..351e841a042880eb7ee252aa23d519f201f05d74 100644 (file)
--- a/src/cargo/ops/cargo_install.rs
+++ b/src/cargo/ops/cargo_install.rs
@@ -92,7 +92,7 @@ pub fn install(root: Option<&str>,
     };
 
     let ws = match overidden_target_dir {
-        Some(dir) => Workspace::one(pkg, config, Some(dir))?,
+        Some(dir) => Workspace::ephemeral(pkg, config, Some(dir))?,
         None => Workspace::new(pkg.manifest_path(), config)?,
     };
     let pkg = ws.current()?;

diff --git a/src/cargo/ops/cargo_package.rs b/src/cargo/ops/cargo_package.rs
index c837e0156db7421e34b96b2ee3f7cfa7bd938112..e27646d9f8f12143ec4f67602ff6f190afd1ccde 100644 (file)
--- a/src/cargo/ops/cargo_package.rs
+++ b/src/cargo/ops/cargo_package.rs
@@ -283,7 +283,7 @@ fn run_verify(ws: &Workspace, tar: &File, opts: &PackageOpts) -> CargoResult<()>
     let new_pkg = Package::new(new_manifest, &manifest_path);
 
     // Now that we've rewritten all our path dependencies, compile it!
-    let ws = Workspace::one(new_pkg, config, None)?;
+    let ws = Workspace::ephemeral(new_pkg, config, None)?;
     ops::compile_ws(&ws, None, &ops::CompileOptions {
         config: config,
         jobs: opts.jobs,

diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
index 76e5e2a0e3e8219bb0ae3a7327817a28544890dc..61f25d23df197be3e0839c649b17e6a14ec1e4ca 100644 (file)
--- a/src/cargo/ops/resolve.rs
+++ b/src/cargo/ops/resolve.rs
@@ -14,7 +14,7 @@ use util::{profile, human, CargoResult, ChainError};
 /// lockfile.
 pub fn resolve_ws<'a>(ws: &Workspace<'a>) -> CargoResult<(PackageSet<'a>, Resolve)> {
     let mut registry = PackageRegistry::new(ws.config())?;
-    let resolve = resolve_with_registry(ws, &mut registry, true)?;
+    let resolve = resolve_with_registry(ws, &mut registry)?;
     let packages = get_resolved_packages(&resolve, registry);
     Ok((packages, resolve))
 }
@@ -33,17 +33,13 @@ pub fn resolve_ws_precisely<'a>(ws: &Workspace<'a>,
     }).map(|s| s.to_string()).collect::<Vec<String>>();
 
     let mut registry = PackageRegistry::new(ws.config())?;
-
-    // Avoid writing a lockfile if we are `cargo install`ing a non local package.
-    let write_lockfile = source.is_none() || ws.current_opt().is_none();
-
     if let Some(source) = source {
         registry.add_preloaded(source);
     }
 
     // First, resolve the root_package's *listed* dependencies, as well as
     // downloading and updating all remotes and such.
-    let resolve = resolve_with_registry(ws, &mut registry, write_lockfile)?;
+    let resolve = resolve_with_registry(ws, &mut registry)?;
 
     // Second, resolve with precisely what we're doing. Filter out
     // transitive dependencies if necessary, specify features, handle
@@ -80,14 +76,14 @@ pub fn resolve_ws_precisely<'a>(ws: &Workspace<'a>,
     Ok((packages, resolved_with_overrides))
 }
 
-fn resolve_with_registry(ws: &Workspace, registry: &mut PackageRegistry, write_lockfile: bool)
+fn resolve_with_registry(ws: &Workspace, registry: &mut PackageRegistry)
                          -> CargoResult<Resolve> {
     let prev = ops::load_pkg_lockfile(ws)?;
     let resolve = resolve_with_previous(registry, ws,
                                         Method::Everything,
                                         prev.as_ref(), None, &[])?;
 
-    if write_lockfile {
+    if !ws.is_ephemeral() {
         ops::write_pkg_lockfile(ws, &resolve)?;
     }
     Ok(resolve)